home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 February / EnigmA AMIGA RUN 04 (1996)(G.R. Edizioni)(IT)[!][issue 1996-02][Skylink CD III].iso / earcd / comm2 / termsorc.lha / Extras / Source / gtlayout-source.lha / LT_HandleInput.c < prev    next >
C/C++ Source or Header  |  1995-09-24  |  48KB  |  2,083 lines
  1. /*  GadTools layout toolkit
  2. **
  3. **  Copyright © 1993-1995 by Olaf `Olsen' Barthel
  4. **  Freely distributable.
  5. */
  6.  
  7. #include "gtlayout_global.h"
  8.  
  9. VOID LIBENT
  10. LT_HandleInput(REG(a0) LayoutHandle *Handle,REG(d0) ULONG MsgQualifier,REG(a1) ULONG *MsgClass,REG(a2) UWORD *MsgCode,REG(a3) struct Gadget **MsgGadget)
  11. {
  12.     ObjectNode    *Node;
  13.     BOOLEAN      Activate = FALSE;
  14.  
  15.     if(!Handle)
  16.         return;
  17.  
  18.     if(Handle -> Failed)
  19.     {
  20.         *MsgClass = IDCMP_CLOSEWINDOW;
  21.  
  22.         if(!Handle -> NeedDelay)
  23.             Handle -> NeedDelay = TRUE;
  24.         else
  25.             LTP_Delay(0,500000);
  26.  
  27.         return;
  28.     }
  29.  
  30.     switch(*MsgClass)
  31.     {
  32.         case IDCMP_CHANGEWINDOW:
  33.  
  34.             if(!(Handle -> Window -> Flags & WFLG_SIZEGADGET) && (Handle -> Window -> Flags & WFLG_HASZOOM) && !V39)
  35.             {
  36. #ifdef DO_BOOPSI_KIND
  37.                 if(Handle -> BOOPSIList)
  38.                     RefreshGList((struct Gadget *)Handle -> BOOPSIList,Handle -> Window,NULL,(UWORD)-1);
  39. #endif    /* DO_BOOPSI_KIND */
  40.  
  41.                 RefreshGList(Handle -> List,Handle -> Window,NULL,(UWORD)-1);
  42.  
  43.                 GT_RefreshWindow(Handle -> Window,NULL);
  44.  
  45.                 LTP_DrawGroup(Handle,Handle -> TopGroup);
  46.             }
  47.  
  48.             break;
  49.  
  50.         case IDCMP_NEWSIZE:
  51.  
  52.                 // Did the user cancel the resize operation?
  53.  
  54.             if(Handle -> SizeVerified && Handle -> SizeWidth == Handle -> Window -> Width && Handle -> SizeHeight == Handle -> Window -> Height)
  55.             {
  56.                 Handle -> SizeVerified    = FALSE;
  57.                 Handle -> SizeWidth    = 0;
  58.                 Handle -> SizeHeight    = 0;
  59.  
  60.                     // Put the gadgets back in
  61.  
  62.                 AddGList(Handle -> Window,Handle -> List,(UWORD)-1,(UWORD)-1,NULL);
  63.             }
  64.             else
  65.             {
  66.                 struct IBox Box;
  67.  
  68.                 Handle -> SizeWidth    = 0;
  69.                 Handle -> SizeHeight    = 0;
  70.  
  71.                 Box . Left    = 0;
  72.                 Box . Top    = 0;
  73.                 Box . Width    = Handle -> Window -> Width;
  74.                 Box . Height    = Handle -> Window -> Height;
  75.  
  76.                 LT_LockWindow(Handle -> Window);
  77.  
  78.                 if(Handle -> ResizeView)
  79.                     Handle -> ResizeView -> Special . List . IgnoreListContents = TRUE;
  80.  
  81.                 LT_RebuildTags(Handle,TRUE,
  82.                     LAWN_Bounds,    &Box,
  83.                 TAG_DONE);
  84.  
  85.                 LT_UnlockWindow(Handle -> Window);
  86.  
  87.                 if(Handle -> Failed)
  88.                     *MsgClass = IDCMP_CLOSEWINDOW;
  89.                 else
  90.                     *MsgClass = NULL;
  91.             }
  92.  
  93.             break;
  94.  
  95.         case IDCMP_REFRESHWINDOW:
  96.  
  97.             if(Handle -> AutoRefresh)
  98.             {
  99.                 LT_BeginRefresh(Handle);
  100.  
  101.                 LT_EndRefresh(Handle,TRUE);
  102.  
  103.                 *MsgClass = NULL;
  104.             }
  105.  
  106.             break;
  107.  
  108.         case IDCMP_INTUITICKS:
  109.  
  110.             if(Handle -> ActiveIncrementer)
  111.             {
  112.                 if(Handle -> IncrementerCountdown > 0)
  113.                     Handle -> IncrementerCountdown--;
  114.  
  115.                 if(Handle -> IncrementerCountdown <= 0)
  116.                 {
  117.                     if(Handle -> ActiveIncrementer -> Host -> Flags & GFLG_SELECTED)
  118.                     {
  119.                         if(Handle -> ActiveIncrementer -> Type == TAPEDECK_KIND)
  120.                         {
  121.                             *MsgClass    = IDCMP_GADGETUP;
  122.                             *MsgCode    = 0;
  123.                             *MsgGadget    = Handle -> ActiveIncrementer -> Host;
  124.                         }
  125.                         else
  126.                         {
  127.                             struct ObjectNode    *Parent;
  128.                             LONG             Number;
  129.  
  130.                             if(Handle -> IncrementerAccelerate > 0 && !(MsgQualifier & (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT)))
  131.                                 Handle -> IncrementerAccelerate--;
  132.  
  133.                             if(Handle -> IncrementerAccelerate <= 0)
  134.                             {
  135.                                 Handle -> IncrementerAccelerate = 10;
  136.  
  137.                                 Handle -> IncrementerIncrement *= 2;
  138.                             }
  139.  
  140.                             *MsgClass    = IDCMP_GADGETUP;
  141.                             *MsgCode    = 0;
  142.                             *MsgGadget    = Handle -> ActiveIncrementer -> Special . Incrementer . Parent;
  143.  
  144.                             Parent = (*MsgGadget) -> UserData;
  145.  
  146.                             if(Parent -> Special . Integer . IncrementerHook)
  147.                                 Number = CallHookPkt(Parent -> Special . Integer . IncrementerHook,(APTR)LT_GetAttributes(Handle,Parent -> ID,LAPR_Object,Parent,TAG_DONE),Handle -> ActiveIncrementer -> Special . Incrementer . Amount < 0 ? (APTR)INCREMENTERMSG_DECREMENT : (APTR)INCREMENTERMSG_INCREMENT);
  148.                             else
  149.                                 Number = ((LONG)LT_GetAttributes(Handle,Parent -> ID,LAPR_Object,Parent,TAG_DONE)) + Handle -> ActiveIncrementer -> Special . Incrementer . Amount * Handle -> IncrementerIncrement;
  150.  
  151.                             if(Number >= Parent -> Min && Number <= Parent -> Max)
  152.                                 LT_SetAttributes(Handle,Parent -> ID,LAPR_Object,Parent,GTIN_Number,Number,TAG_DONE);
  153.                         }
  154.                     }
  155.                     else
  156.                     {
  157.                         Handle -> IncrementerIncrement    = 1;
  158.                         Handle -> IncrementerAccelerate    = 10;
  159.                     }
  160.  
  161.                     if(Handle -> IncrementerIncrement == 1)
  162.                         Handle -> IncrementerCountdown = 2;
  163.                 }
  164.             }
  165.  
  166.             break;
  167.  
  168.         case IDCMP_RAWKEY:
  169.         {
  170.             UBYTE            Buffer[10],Key;
  171.             struct InputEvent    event;
  172.             BOOLEAN         KeyUp;
  173.  
  174.             if((*MsgCode & ~IECODE_UP_PREFIX) == 95 && Handle -> HelpHook)
  175.             {
  176.                 if(!(*MsgCode & IECODE_UP_PREFIX))
  177.                 {
  178.                     ObjectNode    *Item;
  179.                     struct HelpMsg     Message;
  180.                     struct IBox     Box;
  181.  
  182.                     Item = LTP_FindNode_Position(Handle -> TopGroup,Handle -> Window -> MouseX,Handle -> Window -> MouseY);
  183.  
  184.                     if(Item == Handle -> TopGroup)
  185.                     {
  186.                         if(Item -> ID <= PHANTOM_GROUP_ID)
  187.                             Item = NULL;
  188.                     }
  189.  
  190.                     if(Item)
  191.                     {
  192.                         Message . ObjectID = Item -> ID;
  193.  
  194.                         Box . Left    = Item -> Left;
  195.                         Box . Top    = Item -> Top;
  196.                         Box . Width    = Item -> Width;
  197.                         Box . Height    = Item -> Height;
  198.                     }
  199.                     else
  200.                     {
  201.                         Message . ObjectID = -1;
  202.  
  203.                         Box . Left    = 0;
  204.                         Box . Top    = 0;
  205.                         Box . Width    = Handle -> Window -> Width;
  206.                         Box . Height    = Handle -> Window -> Height;
  207.                     }
  208.  
  209.                     Message . Handle = Handle;
  210.  
  211.                     CallHookPkt(Handle -> HelpHook,&Message,&Box);
  212.                 }
  213.  
  214.                 if(Handle -> RawKeyFilter)
  215.                     *MsgClass = NULL;
  216.  
  217.                 break;
  218.             }
  219.  
  220.             if((*MsgCode >= 99 && *MsgCode <= 103) || *MsgCode == 96 || *MsgCode == 97)
  221.             {
  222.                 if(Handle -> RawKeyFilter)
  223.                     *MsgClass = NULL;
  224.  
  225.                 break;
  226.             }
  227.  
  228.             event . ie_NextEvent        = NULL;
  229.             event . ie_Code         = (*MsgCode) & ~IECODE_UP_PREFIX;
  230.             event . ie_Qualifier        = MsgQualifier & ~QUALIFIER_SHIFT;
  231.             event . ie_Class        = IECLASS_RAWKEY;
  232.             event . ie_SubClass        = 0;
  233.             event . ie_position . ie_addr    = (APTR)*MsgGadget;
  234.  
  235.             Buffer[0] = 0;
  236.  
  237.             if(MapRawKey(&event,Buffer,9,NULL) < 1)
  238.             {
  239.                 if(Handle -> RawKeyFilter)
  240.                     *MsgClass = NULL;
  241.  
  242.                 break;
  243.             }
  244.  
  245.             if(!(Key = Buffer[0]))
  246.             {
  247.                 if(Handle -> RawKeyFilter)
  248.                     *MsgClass = NULL;
  249.  
  250.                 break;
  251.             }
  252.  
  253.             if((*MsgCode) & IECODE_UP_PREFIX)
  254.                 KeyUp = TRUE;
  255.             else
  256.                 KeyUp = FALSE;
  257.  
  258.             if(!KeyUp && Handle -> CursorKey && (*MsgCode == CURSORUP || *MsgCode == CURSORDOWN))
  259.             {
  260.                 ObjectNode    *Node;
  261.                 struct Gadget    *Gadget;
  262.                 LONG         NewState;
  263.  
  264.                 Handle -> ClickSeconds = Handle -> ClickMicros = 0;
  265.  
  266.                 Node        = Handle -> CursorKey;
  267.                 Gadget        = Node -> Host;
  268.                 NewState    = Node -> Current;
  269.  
  270.                 if(*MsgCode == CURSORDOWN)
  271.                 {
  272.                     if(MsgQualifier & QUALIFIER_SHIFT)
  273.                         NewState += Node -> Lines;
  274.                     else
  275.                     {
  276.                         if(MsgQualifier & (QUALIFIER_ALT | QUALIFIER_CONTROL))
  277.                             NewState = Node -> Max;
  278.                         else
  279.                             NewState++;
  280.                     }
  281.                 }
  282.                 else
  283.                 {
  284.                     if(MsgQualifier & QUALIFIER_SHIFT)
  285.                         NewState -= Node -> Lines;
  286.                     else
  287.                     {
  288.                         if(MsgQualifier & (QUALIFIER_ALT | QUALIFIER_CONTROL))
  289.                             NewState = Node -> Min;
  290.                         else
  291.                             NewState--;
  292.                     }
  293.                 }
  294.  
  295.                 if(NewState < Node -> Min)
  296.                     NewState = Node -> Min;
  297.                 else
  298.                 {
  299.                     if(NewState > Node -> Max)
  300.                         NewState = Node -> Max;
  301.                 }
  302.  
  303. //                if(NewState != Node -> Current && Node -> Max != Node -> Min)
  304.                 if(NewState != Node -> Current || Node -> Max == Node -> Min)
  305.                 {
  306.                     Node -> Current = NewState;
  307.  
  308.                     GT_SetGadgetAttrs(Gadget,Handle -> Window,NULL,
  309.                         GTLV_Top,        Node -> Current,
  310.                         GTLV_MakeVisible,    Node -> Current,
  311.  
  312.                         Node -> Special . List . LinkID != -1 ? GTLV_Selected : TAG_IGNORE,Node -> Current,
  313.                     TAG_DONE);
  314.  
  315.                     LTP_PutStorage(Node);
  316.  
  317.                     *MsgClass    = IDCMP_GADGETUP;
  318.                     *MsgCode    = Node -> Current;
  319.                     *MsgGadget    = Gadget;
  320.  
  321.                     if(Node -> Special . List . AutoPageID != -1)
  322.                     {
  323.                         LT_SetAttributes(Handle,Node -> Special . List . AutoPageID,
  324.                             LAGR_ActivePage,Node -> Current,
  325.                         TAG_DONE);
  326.                     }
  327.                 }
  328.                 else
  329.                 {
  330.                     if(Handle -> RawKeyFilter)
  331.                         *MsgClass = NULL;
  332.                 }
  333.  
  334.                 return;
  335.             }
  336.  
  337.             if(Key == '\t' && !KeyUp)
  338.             {
  339.                 ObjectNode *Node;
  340.  
  341.                 if(Handle -> RawKeyFilter)
  342.                     *MsgClass = NULL;
  343.  
  344.                 if(Node = Handle -> TabKey)
  345.                 {
  346.                     if(!(Node -> Disabled))
  347.                     {
  348.                         LONG Choice;
  349.  
  350.                         if(MsgQualifier & QUALIFIER_SHIFT)
  351.                             Choice = Node -> Current - 1;
  352.                         else
  353.                             Choice = Node -> Current + 1;
  354.  
  355.                         if(Choice < Node -> Min)
  356.                             Choice = Node -> Max;
  357.                         else
  358.                         {
  359.                             if(Choice > Node -> Max)
  360.                                 Choice = Node -> Min;
  361.                         }
  362.  
  363.                         if(Choice != Node -> Current)
  364.                         {
  365.                             LONG AutoPageID,Type;
  366.  
  367.                             if(Node -> Type == CYCLE_KIND)
  368.                             {
  369.                                 AutoPageID    = Node -> Special . Cycle . AutoPageID;
  370.                                 Type        = GTCY_Active;
  371.                                 *MsgClass    = IDCMP_GADGETUP;
  372.  
  373.                                 LTP_BlinkButton(Handle,Node -> Host);
  374.                             }
  375. #if defined(DO_POPUP_KIND) && defined(DO_BOOPSI_KIND)
  376.                             if(Node -> Type == POPUP_KIND)
  377.                             {
  378.                                 AutoPageID    = Node -> Special . Popup . AutoPageID;
  379.                                 Type        = LAPU_Active;
  380.                                 *MsgClass    = IDCMP_GADGETUP;
  381.  
  382.                                 LTP_BlinkButton(Handle,Node -> Host);
  383.                             }
  384. #endif
  385. #if defined(DO_TAB_KIND) && defined(DO_BOOPSI_KIND)
  386.                             if(Node -> Type == TAB_KIND)
  387.                             {
  388.                                 AutoPageID    = Node -> Special . Tab . AutoPageID;
  389.                                 Type        = LATB_Active;
  390.                                 *MsgClass    = IDCMP_GADGETUP;
  391.                             }
  392. #endif
  393.                             if(Node -> Type == MX_KIND)
  394.                             {
  395.                                 AutoPageID    = Node -> Special . Radio . AutoPageID;
  396.                                 Type        = GTMX_Active;
  397.                                 *MsgClass    = IDCMP_GADGETDOWN;
  398.                             }
  399.  
  400.                             *MsgCode    = (UWORD)Choice;
  401.                             *MsgGadget    = Node -> Host;
  402.  
  403.                             LT_SetAttributes(Handle,Node -> ID,
  404.                                 Type,Choice,
  405.                             TAG_DONE);
  406.  
  407.                             if(AutoPageID != -1)
  408.                             {
  409.                                 LT_SetAttributes(Handle,AutoPageID,
  410.                                     LAGR_ActivePage,Choice,
  411.                                 TAG_DONE);
  412.  
  413.                                 if(Handle -> Failed)
  414.                                     *MsgClass = IDCMP_CLOSEWINDOW;
  415.                             }
  416.                         }
  417.                     }
  418.                 }
  419.  
  420.                 return;
  421.             }
  422.  
  423.             if(Key == '\33' && !KeyUp)
  424.             {
  425.                 ObjectNode *Node;
  426.  
  427.                 Handle -> ClickSeconds = Handle -> ClickMicros = 0;
  428.  
  429.                 if(Node = Handle -> EscKey)
  430.                 {
  431.                     if(!Node -> Disabled)
  432.                     {
  433.                         LTP_BlinkButton(Handle,Node -> Host);
  434.  
  435.                         *MsgCode    = 0;
  436.                         *MsgGadget    = Node -> Host;
  437.                         *MsgClass    = IDCMP_GADGETUP;
  438.                     }
  439.                     else
  440.                     {
  441.                         if(Handle -> RawKeyFilter)
  442.                             *MsgClass = NULL;
  443.                     }
  444.  
  445.                     return;
  446.                 }
  447.  
  448.                 if(Handle -> Window -> Flags & WFLG_CLOSEGADGET)
  449.                 {
  450.                     *MsgCode    = 0;
  451.                     *MsgGadget    = NULL;
  452.                     *MsgClass    = IDCMP_CLOSEWINDOW;
  453.                 }
  454.                 else
  455.                 {
  456.                     if(Handle -> RawKeyFilter)
  457.                         *MsgClass = NULL;
  458.                 }
  459.  
  460.                 return;
  461.             }
  462.             else
  463.             {
  464.                 struct Gadget    *Gadget;
  465.                 ObjectNode    *Node;
  466.                 LONG         i;
  467.                 BOOLEAN      FoundIt = FALSE,
  468.                          Forward;
  469.  
  470.                 if(MsgQualifier & QUALIFIER_SHIFT)
  471.                     Forward = FALSE;
  472.                 else
  473.                     Forward = TRUE;
  474.  
  475.                 if(Handle -> ReturnKey && Key == '\r')
  476.                 {
  477.                     Node = Handle -> ReturnKey;
  478.  
  479.                     if(!KeyUp && !Node -> Disabled)
  480.                     {
  481.                         LTP_BlinkButton(Handle,Node -> Host);
  482.  
  483.                         *MsgClass    = IDCMP_GADGETUP;
  484.                         *MsgCode    = 0;
  485.                         *MsgGadget    = Node -> Host;
  486.                     }
  487.                     else
  488.                     {
  489.                         if(Handle -> RawKeyFilter)
  490.                             *MsgClass = NULL;
  491.                     }
  492.  
  493.                     Handle -> ClickSeconds = Handle -> ClickMicros = 0;
  494.  
  495.                     return;
  496.                 }
  497.  
  498.                 for(i = 0 ; !FoundIt && i < Handle -> Count ; i++)
  499.                 {
  500.                     if(Gadget = Handle -> GadgetArray[i])
  501.                     {
  502.                         if(GETOBJECT(Gadget,Node))
  503.                         {
  504.                             if(Key == Node -> Key)
  505.                             {
  506.                                 if(Node -> Disabled)
  507.                                     break;
  508.                                 else
  509.                                 {
  510.                                     switch(Node -> Type)
  511.                                     {
  512. #ifdef DO_BOOPSI_KIND
  513.                                         case BOOPSI_KIND:
  514.  
  515.                                             if(!KeyUp && !(MsgQualifier & IEQUALIFIER_REPEAT))
  516.                                             {
  517.                                                 if(Node -> Special . BOOPSI . ActivateHook)
  518.                                                 {
  519.                                                     if(CallHookPkt(Node -> Special . BOOPSI . ActivateHook,(APTR)Handle,(APTR)Node -> Host))
  520.                                                     {
  521.                                                         if(Handle -> RawKeyFilter)
  522.                                                             *MsgClass = NULL;
  523.  
  524.                                                         break;
  525.                                                     }
  526.                                                 }
  527.  
  528.                                                 *MsgClass    = IDCMP_GADGETUP;
  529.                                                 *MsgCode    = (MsgQualifier & QUALIFIER_SHIFT) ? -1 : 1;
  530.                                                 *MsgGadget    = Gadget;
  531.                                             }
  532.                                             else
  533.                                             {
  534.                                                 if(Handle -> RawKeyFilter)
  535.                                                     *MsgClass = NULL;
  536.                                             }
  537.  
  538.                                             break;
  539. #ifdef DO_POPUP_KIND
  540.                                         case POPUP_KIND:
  541.  
  542.                                             if(!KeyUp && !(MsgQualifier & IEQUALIFIER_REPEAT))
  543.                                             {
  544.                                                 LONG Choice;
  545.  
  546.                                                 if(MsgQualifier & QUALIFIER_SHIFT)
  547.                                                     Choice = Node -> Current - 1;
  548.                                                 else
  549.                                                     Choice = Node -> Current + 1;
  550.  
  551.                                                 if(Choice < Node -> Min)
  552.                                                     Choice = Node -> Max;
  553.                                                 else
  554.                                                 {
  555.                                                     if(Choice > Node -> Max)
  556.                                                         Choice = Node -> Min;
  557.                                                 }
  558.  
  559.                                                 if(Choice != Node -> Current)
  560.                                                 {
  561.                                                     LTP_BlinkButton(Handle,Node -> Host);
  562.  
  563.                                                     *MsgClass    = IDCMP_GADGETUP;
  564.                                                     *MsgCode    = (UWORD)Choice;
  565.                                                     *MsgGadget    = Node -> Host;
  566.  
  567.                                                     LT_SetAttributes(Handle,0,
  568.                                                         LAPR_Gadget,    Node -> Host,
  569.                                                         LAPU_Active,    Choice,
  570.                                                     TAG_DONE);
  571.                                                 }
  572.                                             }
  573.                                             else
  574.                                             {
  575.                                                 if(Handle -> RawKeyFilter)
  576.                                                     *MsgClass = NULL;
  577.                                             }
  578.  
  579.                                             break;
  580. #endif    // DO_POPUP_KIND
  581.  
  582. #ifdef DO_TAB_KIND
  583.                                         case TAB_KIND:
  584.  
  585.                                             if(!KeyUp && !(MsgQualifier & IEQUALIFIER_REPEAT))
  586.                                             {
  587.                                                 LONG Choice;
  588.  
  589.                                                 if(MsgQualifier & QUALIFIER_SHIFT)
  590.                                                     Choice = Node -> Current - 1;
  591.                                                 else
  592.                                                     Choice = Node -> Current + 1;
  593.  
  594.                                                 if(Choice < Node -> Min)
  595.                                                     Choice = Node -> Max;
  596.                                                 else
  597.                                                 {
  598.                                                     if(Choice > Node -> Max)
  599.                                                         Choice = Node -> Min;
  600.                                                 }
  601.  
  602.                                                 if(Choice != Node -> Current)
  603.                                                 {
  604.                                                     *MsgClass    = IDCMP_GADGETUP;
  605.                                                     *MsgCode    = (UWORD)Choice;
  606.                                                     *MsgGadget    = Node -> Host;
  607.  
  608.                                                     LT_SetAttributes(Handle,0,
  609.                                                         LAPR_Gadget,    Node -> Host,
  610.                                                         LAPU_Active,    Choice,
  611.                                                     TAG_DONE);
  612.                                                 }
  613.                                             }
  614.                                             else
  615.                                             {
  616.                                                 if(Handle -> RawKeyFilter)
  617.                                                     *MsgClass = NULL;
  618.                                             }
  619.  
  620.                                             break;
  621. #endif    // DO_TAB_KIND
  622. #endif    /* DO_BOOPSI_KIND */
  623. #ifdef DO_TAPEDECK_KIND
  624.                                         case TAPEDECK_KIND:
  625.  
  626.                                             if(!KeyUp && !(MsgQualifier & IEQUALIFIER_REPEAT))
  627.                                             {
  628.                                                 if(Node -> Special . TapeDeck . Toggle)
  629.                                                 {
  630.                                                     LT_SetAttributes(Handle,Node -> ID,
  631.                                                         LAPR_Object,    Node,
  632.                                                         LATD_Pressed,    !Node -> Current,
  633.                                                     TAG_DONE);
  634.  
  635.                                                     LTP_PutStorage(Node);
  636.                                                 }
  637.                                                 else
  638.                                                     LTP_BlinkButton(Handle,Gadget);
  639.  
  640.                                                 if(Gadget -> Flags & GFLG_SELECTED)
  641.                                                     *MsgCode = TRUE;
  642.                                                 else
  643.                                                     *MsgCode = FALSE;
  644.  
  645.                                                 *MsgClass    = IDCMP_GADGETUP;
  646.                                                 *MsgGadget    = Gadget;
  647.                                             }
  648.                                             else
  649.                                             {
  650.                                                 if(Handle -> RawKeyFilter)
  651.                                                     *MsgClass = NULL;
  652.                                             }
  653.  
  654.                                             break;
  655. #endif    /* DO_TAPEDECK_KIND */
  656.                                         case CHECKBOX_KIND:
  657.  
  658.                                             if(!KeyUp && !(MsgQualifier & IEQUALIFIER_REPEAT))
  659.                                             {
  660.                                                 Node -> Current = !Node -> Current;
  661.  
  662.                                                 LTP_PutStorage(Node);
  663.  
  664.                                                 GT_SetGadgetAttrs(Gadget,Handle -> Window,NULL,
  665.                                                     GTCB_Checked,Node -> Current,
  666.                                                 TAG_DONE);
  667.  
  668.                                                 *MsgClass    = IDCMP_GADGETUP;
  669.                                                 *MsgCode    = Node -> Current;
  670.                                                 *MsgGadget    = Gadget;
  671.                                             }
  672.                                             else
  673.                                             {
  674.                                                 if(Handle -> RawKeyFilter)
  675.                                                     *MsgClass = NULL;
  676.                                             }
  677.  
  678.                                             FoundIt = TRUE;
  679.  
  680.                                             break;
  681.  
  682.                                         case LISTVIEW_KIND:
  683.  
  684.                                             if(!KeyUp)
  685.                                             {
  686.                                                 BOOLEAN setAttrs = FALSE;
  687.  
  688.                                                 if(Forward)
  689.                                                 {
  690.                                                     if(Node -> Current < Node -> Max)
  691.                                                     {
  692.                                                         Node -> Current++;
  693.  
  694.                                                         setAttrs = TRUE;
  695.                                                     }
  696.                                                 }
  697.                                                 else
  698.                                                 {
  699.                                                     if(Node -> Current > Node -> Min)
  700.                                                     {
  701.                                                         Node -> Current--;
  702.  
  703.                                                         setAttrs = TRUE;
  704.                                                     }
  705.                                                 }
  706.  
  707.                                                 if(setAttrs)
  708.                                                 {
  709.                                                     if(Node -> Current < 0)
  710.                                                     {
  711.                                                         GT_SetGadgetAttrs(Gadget,Handle -> Window,NULL,
  712.                                                             GTLV_Selected,Node -> Current,
  713.                                                         TAG_DONE);
  714.                                                     }
  715.                                                     else
  716.                                                     {
  717.                                                         GT_SetGadgetAttrs(Gadget,Handle -> Window,NULL,
  718.                                                             GTLV_Top,        Node -> Current,
  719.                                                             GTLV_MakeVisible,    Node -> Current,
  720.                                                             Node -> Special . List . LinkID != -1 ? GTLV_Selected : TAG_IGNORE,Node -> Current,
  721.                                                         TAG_DONE);
  722.                                                     }
  723.  
  724.                                                     LTP_PutStorage(Node);
  725.  
  726.                                                     *MsgClass    = IDCMP_GADGETUP;
  727.                                                     *MsgCode    = Node -> Current;
  728.                                                     *MsgGadget    = Gadget;
  729.  
  730.                                                     if(Node -> Special . List . AutoPageID != -1)
  731.                                                     {
  732.                                                         LT_SetAttributes(Handle,Node -> Special . List . AutoPageID,
  733.                                                             LAGR_ActivePage,Node -> Current,
  734.                                                         TAG_DONE);
  735.                                                     }
  736.                                                 }
  737.                                                 else
  738.                                                 {
  739.                                                     if(Handle -> RawKeyFilter)
  740.                                                         *MsgClass = NULL;
  741.                                                 }
  742.                                             }
  743.                                             else
  744.                                             {
  745.                                                 if(Handle -> RawKeyFilter)
  746.                                                     *MsgClass = NULL;
  747.                                             }
  748.  
  749.                                             FoundIt = TRUE;
  750.  
  751.                                             break;
  752.  
  753.                                         case MX_KIND:
  754.  
  755.                                             if(!KeyUp)
  756.                                             {
  757.                                                 if(Forward)
  758.                                                 {
  759.                                                     if(Node -> Current < Node -> Max)
  760.                                                     {
  761.                                                         Node -> Current++;
  762.  
  763.                                                         GT_SetGadgetAttrs(Gadget,Handle -> Window,NULL,
  764.                                                             GTMX_Active,Node -> Current,
  765.                                                         TAG_DONE);
  766.  
  767.                                                         LTP_PutStorage(Node);
  768.  
  769.                                                         *MsgClass    = IDCMP_GADGETDOWN;
  770.                                                         *MsgCode    = Node -> Current;
  771.                                                         *MsgGadget    = Gadget;
  772.                                                     }
  773.                                                     else
  774.                                                     {
  775.                                                         if(Handle -> RawKeyFilter)
  776.                                                             *MsgClass = NULL;
  777.                                                     }
  778.                                                 }
  779.                                                 else
  780.                                                 {
  781.                                                     if(Node -> Current > Node -> Min)
  782.                                                     {
  783.                                                         Node -> Current--;
  784.  
  785.                                                         GT_SetGadgetAttrs(Gadget,Handle -> Window,NULL,
  786.                                                             GTMX_Active,Node -> Current,
  787.                                                         TAG_DONE);
  788.  
  789.                                                         LTP_PutStorage(Node);
  790.  
  791.                                                         *MsgClass    = IDCMP_GADGETDOWN;
  792.                                                         *MsgCode    = Node -> Current;
  793.                                                         *MsgGadget    = Gadget;
  794.                                                     }
  795.                                                     else
  796.                                                         *MsgClass = NULL;
  797.                                                 }
  798.                                             }
  799.                                             else
  800.                                                 *MsgClass = NULL;
  801.  
  802.                                             if(*MsgClass)
  803.                                             {
  804.                                                 if(Node -> Special . Radio . AutoPageID != -1)
  805.                                                 {
  806.                                                     LT_SetAttributes(Handle,Node -> Special . Radio . AutoPageID,
  807.                                                         LAGR_ActivePage,Node -> Current,
  808.                                                     TAG_DONE);
  809.  
  810.                                                     if(Handle -> Failed)
  811.                                                         *MsgClass = IDCMP_CLOSEWINDOW;
  812.                                                     else
  813.                                                     {
  814.                                                         if(Handle -> RawKeyFilter)
  815.                                                             *MsgClass = NULL;
  816.                                                     }
  817.                                                 }
  818.                                             }
  819.  
  820.                                             FoundIt = TRUE;
  821.  
  822.                                             break;
  823.  
  824.                                         case TEXT_KIND:
  825.  
  826.                                             if(!KeyUp && !(MsgQualifier & IEQUALIFIER_REPEAT))
  827.                                             {
  828.                                                 if(Node -> Special . Text . Picker)
  829.                                                 {
  830.                                                     LTP_BlinkButton(Handle,Node -> Special . Text . Picker);
  831.  
  832.                                                     *MsgClass    = IDCMP_IDCMPUPDATE;
  833.                                                     *MsgCode    = 0;
  834.                                                     *MsgGadget    = Gadget;
  835.                                                 }
  836.                                                 else
  837.                                                 {
  838.                                                     if(Handle -> RawKeyFilter)
  839.                                                         *MsgClass = NULL;
  840.                                                 }
  841.                                             }
  842.                                             else
  843.                                             {
  844.                                                 if(Handle -> RawKeyFilter)
  845.                                                     *MsgClass = NULL;
  846.                                             }
  847.  
  848.                                             FoundIt = TRUE;
  849.  
  850.                                             break;
  851.  
  852.                                         case NUMBER_KIND:
  853.  
  854.                                             if(Handle -> RawKeyFilter)
  855.                                                 *MsgClass = NULL;
  856.  
  857.                                             FoundIt = TRUE;
  858.  
  859.                                             break;
  860.  
  861.                                         case CYCLE_KIND:
  862.  
  863.                                             if(!KeyUp && !(MsgQualifier & IEQUALIFIER_REPEAT))
  864.                                             {
  865.                                                 LTP_BlinkButton(Handle,Gadget);
  866.  
  867.                                                 if(Forward)
  868.                                                 {
  869.                                                     if(Node -> Current < Node -> Max)
  870.                                                         Node -> Current++;
  871.                                                     else
  872.                                                         Node -> Current = Node -> Min;
  873.                                                 }
  874.                                                 else
  875.                                                 {
  876.                                                     if(Node -> Current > Node -> Min)
  877.                                                         Node -> Current--;
  878.                                                     else
  879.                                                         Node -> Current = Node -> Max;
  880.                                                 }
  881.  
  882.                                                 LTP_PutStorage(Node);
  883.  
  884.                                                 GT_SetGadgetAttrs(Gadget,Handle -> Window,NULL,
  885.                                                     GTCY_Active,Node -> Current,
  886.                                                 TAG_DONE);
  887.  
  888.                                                 *MsgClass    = IDCMP_GADGETUP;
  889.                                                 *MsgCode    = Node -> Current;
  890.                                                 *MsgGadget    = Gadget;
  891.  
  892.                                                 if(Node -> Special . Cycle . AutoPageID != -1)
  893.                                                 {
  894.                                                     LT_SetAttributes(Handle,Node -> Special . Cycle . AutoPageID,
  895.                                                         LAGR_ActivePage,Node -> Current,
  896.                                                     TAG_DONE);
  897.  
  898.                                                     if(Handle -> Failed)
  899.                                                         *MsgClass = IDCMP_CLOSEWINDOW;
  900.                                                     else
  901.                                                     {
  902.                                                         if(Handle -> RawKeyFilter)
  903.                                                             *MsgClass = NULL;
  904.                                                     }
  905.                                                 }
  906.                                             }
  907.                                             else
  908.                                             {
  909.                                                 if(Handle -> RawKeyFilter)
  910.                                                     *MsgClass = NULL;
  911.                                             }
  912.  
  913.                                             FoundIt = TRUE;
  914.  
  915.                                             break;
  916.  
  917.                                         case PALETTE_KIND:
  918.  
  919.                                             if(!KeyUp)
  920.                                             {
  921.                                                 if(Node -> Special . Palette . UsePicker)
  922.                                                 {
  923.                                                     if(!(MsgQualifier & IEQUALIFIER_REPEAT))
  924.                                                     {
  925.                                                         LTP_BlinkButton(Handle,Node -> Special . Palette . Picker);
  926.  
  927.                                                         *MsgClass    = IDCMP_IDCMPUPDATE;
  928.                                                         *MsgCode    = 0;
  929.                                                         *MsgGadget    = Gadget;
  930.                                                     }
  931.                                                     else
  932.                                                     {
  933.                                                         if(Handle -> RawKeyFilter)
  934.                                                             *MsgClass = NULL;
  935.                                                     }
  936.  
  937.                                                     FoundIt = TRUE;
  938.  
  939.                                                     break;
  940.                                                 }
  941.  
  942.                                                 if(Node -> Special . Palette . TranslateBack)
  943.                                                 {
  944.                                                     LONG Index = Node -> Special . Palette . TranslateBack[Node -> Current];
  945.  
  946.                                                     if(Index < Node -> Min)
  947.                                                         Index = Node -> Min;
  948.                                                     else
  949.                                                     {
  950.                                                         if(Index > Node -> Max)
  951.                                                             Index = Node -> Max;
  952.                                                     }
  953.  
  954.                                                     if(Forward)
  955.                                                     {
  956.                                                         if(Index < Node -> Max)
  957.                                                             Index++;
  958.                                                         else
  959.                                                             Index = Node -> Min;
  960.                                                     }
  961.                                                     else
  962.                                                     {
  963.                                                         if(Index > Node -> Min)
  964.                                                             Index--;
  965.                                                         else
  966.                                                             Index = Node -> Max;
  967.                                                     }
  968.  
  969.                                                     if(Index < Node -> Min)
  970.                                                         Index = Node -> Min;
  971.                                                     else
  972.                                                     {
  973.                                                         if(Index > Node -> Max)
  974.                                                             Index = Node -> Max;
  975.                                                     }
  976.  
  977.                                                     Node -> Current = Node -> Special . Palette . ColourTable[Index];
  978.                                                 }
  979.                                                 else
  980.                                                 {
  981.                                                     if(Forward)
  982.                                                     {
  983.                                                         if(Node -> Current < Node -> Max)
  984.                                                             Node -> Current++;
  985.                                                         else
  986.                                                             Node -> Current = Node -> Min;
  987.                                                     }
  988.                                                     else
  989.                                                     {
  990.                                                         if(Node -> Current > Node -> Min)
  991.                                                             Node -> Current--;
  992.                                                         else
  993.                                                             Node -> Current = Node -> Max;
  994.                                                     }
  995.                                                 }
  996.  
  997.                                                 LTP_PutStorage(Node);
  998.  
  999.                                                 GT_SetGadgetAttrs(Gadget,Handle -> Window,NULL,
  1000.                                                     GTPA_Color,Node -> Current,
  1001.                                                 TAG_DONE);
  1002.  
  1003.                                                 *MsgClass    = IDCMP_GADGETUP;
  1004.                                                 *MsgCode    = Node -> Current;
  1005.                                                 *MsgGadget    = Gadget;
  1006.                                             }
  1007.                                             else
  1008.                                             {
  1009.                                                 if(Handle -> RawKeyFilter)
  1010.                                                     *MsgClass = NULL;
  1011.                                             }
  1012.  
  1013.                                             FoundIt = TRUE;
  1014.  
  1015.                                             break;
  1016.  
  1017.                                         case SLIDER_KIND:
  1018.  
  1019.                                             if(KeyUp)
  1020.                                             {
  1021.                                                 *MsgClass    = IDCMP_GADGETUP;
  1022.                                                 *MsgCode    = Node -> Current;
  1023.                                                 *MsgGadget    = Gadget;
  1024.                                             }
  1025.                                             else
  1026.                                             {
  1027.                                                 if(Forward)
  1028.                                                 {
  1029.                                                     if(Node -> Current < Node -> Max)
  1030.                                                     {
  1031.                                                         Node -> Current++;
  1032.  
  1033.                                                         GT_SetGadgetAttrs(Gadget,Handle -> Window,NULL,
  1034.                                                             GTSL_Level,Node -> Current,
  1035.                                                         TAG_DONE);
  1036.  
  1037.                                                         LTP_PutStorage(Node);
  1038.  
  1039.                                                         *MsgClass    = IDCMP_MOUSEMOVE;
  1040.                                                         *MsgCode    = Node -> Current;
  1041.                                                         *MsgGadget    = Gadget;
  1042.                                                     }
  1043.                                                     else
  1044.                                                     {
  1045.                                                         if(Handle -> RawKeyFilter)
  1046.                                                             *MsgClass = NULL;
  1047.                                                     }
  1048.                                                 }
  1049.                                                 else
  1050.                                                 {
  1051.                                                     if(Node -> Current > Node -> Min)
  1052.                                                     {
  1053.                                                         Node -> Current--;
  1054.  
  1055.                                                         GT_SetGadgetAttrs(Gadget,Handle -> Window,NULL,
  1056.                                                             GTSL_Level,Node -> Current,
  1057.                                                         TAG_DONE);
  1058.  
  1059.                                                         LTP_PutStorage(Node);
  1060.  
  1061.                                                         *MsgClass    = IDCMP_MOUSEMOVE;
  1062.                                                         *MsgCode    = Node -> Current;
  1063.                                                         *MsgGadget    = Gadget;
  1064.                                                     }
  1065.                                                     else
  1066.                                                     {
  1067.                                                         if(Handle -> RawKeyFilter)
  1068.                                                             *MsgClass = NULL;
  1069.                                                     }
  1070.                                                 }
  1071.                                             }
  1072.  
  1073.                                             FoundIt = TRUE;
  1074.  
  1075.                                             break;
  1076.  
  1077. #ifdef DO_LEVEL_KIND
  1078.                                         case LEVEL_KIND:
  1079.  
  1080.                                             if(KeyUp)
  1081.                                             {
  1082.                                                 *MsgClass    = IDCMP_GADGETUP;
  1083.                                                 *MsgCode    = Node -> Special . Level . Level;
  1084.                                                 *MsgGadget    = Gadget;
  1085.  
  1086.                                                 LTP_PutStorage(Node);
  1087.                                             }
  1088.                                             else
  1089.                                             {
  1090.                                                 if(Forward)
  1091.                                                 {
  1092.                                                     if(Node -> Special . Level . Level < Node -> Special . Level . Max)
  1093.                                                     {
  1094.                                                         Node -> Special . Level . Level++;
  1095.  
  1096.                                                         LT_SetAttributes(Handle,Node -> ID,
  1097.                                                             LAPR_Object,    Node,
  1098.                                                             LAVL_Level,    Node -> Special . Level . Level,
  1099.                                                         TAG_DONE);
  1100.  
  1101.                                                         LTP_PutStorage(Node);
  1102.  
  1103.                                                         *MsgClass    = IDCMP_MOUSEMOVE;
  1104.                                                         *MsgCode    = Node -> Special . Level . Level;
  1105.                                                         *MsgGadget    = Gadget;
  1106.                                                     }
  1107.                                                     else
  1108.                                                     {
  1109.                                                         if(Handle -> RawKeyFilter)
  1110.                                                             *MsgClass = NULL;
  1111.                                                     }
  1112.                                                 }
  1113.                                                 else
  1114.                                                 {
  1115.                                                     if(Node -> Special . Level . Level > Node -> Special . Level . Min)
  1116.                                                     {
  1117.                                                         Node -> Special . Level . Level--;
  1118.  
  1119.                                                         LT_SetAttributes(Handle,Node -> ID,
  1120.                                                             LAPR_Object,    Node,
  1121.                                                             LAVL_Level,    Node -> Special . Level . Level,
  1122.                                                         TAG_DONE);
  1123.  
  1124.                                                         LTP_PutStorage(Node);
  1125.  
  1126.                                                         *MsgClass    = IDCMP_MOUSEMOVE;
  1127.                                                         *MsgCode    = Node -> Special . Level . Level;
  1128.                                                         *MsgGadget    = Gadget;
  1129.                                                     }
  1130.                                                     else
  1131.                                                     {
  1132.                                                         if(Handle -> RawKeyFilter)
  1133.                                                             *MsgClass = NULL;
  1134.                                                     }
  1135.                                                 }
  1136.                                             }
  1137.  
  1138.                                             FoundIt = TRUE;
  1139.  
  1140.                                             break;
  1141. #endif    /* DO_LEVEL_KIND */
  1142.                                         case SCROLLER_KIND:
  1143.  
  1144.                                             if(KeyUp)
  1145.                                             {
  1146.                                                 *MsgClass    = IDCMP_GADGETUP;
  1147.                                                 *MsgCode    = Node -> Current;
  1148.                                                 *MsgGadget    = Gadget;
  1149.                                             }
  1150.                                             else
  1151.                                             {
  1152.                                                 if(Forward)
  1153.                                                 {
  1154.                                                     if(Node -> Current < Node -> Max)
  1155.                                                     {
  1156.                                                         Node -> Current++;
  1157.  
  1158.                                                         GT_SetGadgetAttrs(Gadget,Handle -> Window,NULL,
  1159.                                                             GTSC_Top,Node -> Current,
  1160.                                                         TAG_DONE);
  1161.  
  1162.                                                         LTP_PutStorage(Node);
  1163.  
  1164.                                                         *MsgClass    = IDCMP_MOUSEMOVE;
  1165.                                                         *MsgCode    = Node -> Current;
  1166.                                                         *MsgGadget    = Gadget;
  1167.                                                     }
  1168.                                                     else
  1169.                                                     {
  1170.                                                         if(Handle -> RawKeyFilter)
  1171.                                                             *MsgClass = NULL;
  1172.                                                     }
  1173.                                                 }
  1174.                                                 else
  1175.                                                 {
  1176.                                                     if(Node -> Current > Node -> Min)
  1177.                                                     {
  1178.                                                         Node -> Current--;
  1179.  
  1180.                                                         GT_SetGadgetAttrs(Gadget,Handle -> Window,NULL,
  1181.                                                             GTSC_Top,Node -> Current,
  1182.                                                         TAG_DONE);
  1183.  
  1184.                                                         LTP_PutStorage(Node);
  1185.  
  1186.                                                         *MsgClass    = IDCMP_MOUSEMOVE;
  1187.                                                         *MsgCode    = Node -> Current;
  1188.                                                         *MsgGadget    = Gadget;
  1189.                                                     }
  1190.                                                     else
  1191.                                                     {
  1192.                                                         if(Handle -> RawKeyFilter)
  1193.                                                             *MsgClass = NULL;
  1194.                                                     }
  1195.                                                 }
  1196.                                             }
  1197.  
  1198.                                             FoundIt = TRUE;
  1199.  
  1200.                                             break;
  1201.  
  1202.                                         case STRING_KIND:
  1203.                                         case FRACTION_KIND:
  1204.                                         case PASSWORD_KIND:
  1205.  
  1206.                                             if(!KeyUp)
  1207.                                             {
  1208.                                                 if(Node -> Special . String . Picker && !Forward)
  1209.                                                 {
  1210.                                                     LTP_BlinkButton(Handle,Node -> Special . String . Picker);
  1211.  
  1212.                                                     *MsgClass    = IDCMP_IDCMPUPDATE;
  1213.                                                     *MsgCode    = 0;
  1214.                                                     *MsgGadget    = Gadget;
  1215.                                                 }
  1216.                                                 else
  1217.                                                 {
  1218.                                                     ActivateGadget(Gadget,Handle -> Window,NULL);
  1219.  
  1220.                                                     *MsgClass    = IDCMP_GADGETDOWN;
  1221.                                                     *MsgCode    = 0;
  1222.                                                     *MsgGadget    = Gadget;
  1223.  
  1224.                                                     Handle -> Previous = Gadget;
  1225.                                                 }
  1226.                                             }
  1227.                                             else
  1228.                                             {
  1229.                                                 if(Handle -> RawKeyFilter)
  1230.                                                     *MsgClass = NULL;
  1231.                                             }
  1232.  
  1233.                                             FoundIt = TRUE;
  1234.  
  1235.                                             break;
  1236.  
  1237.                                         case INTEGER_KIND :
  1238.  
  1239.                                             if(!KeyUp)
  1240.                                             {
  1241.                                                 if(Node -> Special . Integer . UseIncrementers)
  1242.                                                 {
  1243.                                                     ObjectNode    *incNode,*Parent = (ObjectNode *)Gadget -> UserData;
  1244.                                                     LONG         Number;
  1245.                                                     struct Gadget    *Incrementer;
  1246.  
  1247.                                                     if(Forward)
  1248.                                                     {
  1249.                                                         incNode = Node -> Special . Integer . RightIncrementer -> UserData;
  1250.  
  1251.                                                         Incrementer = Node -> Special . Integer . RightIncrementer;
  1252.                                                     }
  1253.                                                     else
  1254.                                                     {
  1255.                                                         incNode = Node -> Special . Integer . LeftIncrementer -> UserData;
  1256.  
  1257.                                                         Incrementer = Node -> Special . Integer . LeftIncrementer;
  1258.                                                     }
  1259.  
  1260.                                                     if(Parent -> Special . Integer . IncrementerHook)
  1261.                                                         Number = CallHookPkt(Parent -> Special . Integer . IncrementerHook,(APTR)LT_GetAttributes(Handle,Parent -> ID,LAPR_Object,Parent,TAG_DONE),incNode -> Special . Incrementer . Amount < 0 ? (APTR)INCREMENTERMSG_DECREMENT : (APTR)INCREMENTERMSG_INCREMENT);
  1262.                                                     else
  1263.                                                         Number = LT_GetAttributes(Handle,Parent -> ID,LAPR_Object,Parent,TAG_DONE) + incNode -> Special . Incrementer . Amount;
  1264.  
  1265.                                                     if(Number >= Parent -> Min && Number <= Parent -> Max)
  1266.                                                     {
  1267.                                                         LTP_BlinkButton(Handle,Incrementer);
  1268.  
  1269.                                                         LT_SetAttributes(Handle,Parent -> ID,LAPR_Object,Parent,GTIN_Number,Number,TAG_DONE);
  1270.  
  1271.                                                         *MsgClass = IDCMP_GADGETUP;
  1272.  
  1273.                                                         LTP_PutStorage(Node);
  1274.                                                     }
  1275.                                                 }
  1276.                                                 else
  1277.                                                 {
  1278.                                                     ActivateGadget(Gadget,Handle -> Window,NULL);
  1279.  
  1280.                                                     *MsgClass = IDCMP_GADGETDOWN;
  1281.                                                 }
  1282.  
  1283.                                                 *MsgCode    = 0;
  1284.                                                 *MsgGadget    = Gadget;
  1285.  
  1286.                                                 Handle -> Previous = Gadget;
  1287.                                             }
  1288.                                             else
  1289.                                             {
  1290.                                                 if(Handle -> RawKeyFilter)
  1291.                                                     *MsgClass = NULL;
  1292.                                             }
  1293.  
  1294.                                             FoundIt = TRUE;
  1295.  
  1296.                                             break;
  1297.  
  1298.                                         case BUTTON_KIND:
  1299.  
  1300.                                             if(!KeyUp && !(MsgQualifier & IEQUALIFIER_REPEAT))
  1301.                                             {
  1302.                                                 LTP_BlinkButton(Handle,Gadget);
  1303.  
  1304.                                                 *MsgClass    = IDCMP_GADGETUP;
  1305.                                                 *MsgCode    = 0;
  1306.                                                 *MsgGadget    = Gadget;
  1307.                                             }
  1308.                                             else
  1309.                                             {
  1310.                                                 if(Handle -> RawKeyFilter)
  1311.                                                     *MsgClass = NULL;
  1312.                                             }
  1313.  
  1314.                                             FoundIt = TRUE;
  1315.  
  1316.                                             break;
  1317.                                     }
  1318.                                 }
  1319.                             }
  1320.                         }
  1321.                     }
  1322.                 }
  1323.  
  1324.                 if(FoundIt)
  1325.                     Handle -> ClickSeconds = Handle -> ClickMicros = 0;
  1326.             }
  1327.  
  1328.             break;
  1329.         }
  1330.  
  1331.         case IDCMP_GADGETDOWN:
  1332.  
  1333.             if(GETOBJECT((*MsgGadget),Node))
  1334.             {
  1335.                 if(Node -> Type != LISTVIEW_KIND)
  1336.                     Handle -> ClickSeconds = Handle -> ClickMicros = 0;
  1337.  
  1338.                 switch(Node -> Type)
  1339.                 {
  1340. #ifdef DO_LEVEL_KIND
  1341.                     case LEVEL_KIND:
  1342.  
  1343.                         Handle -> CurrentLevel = Node;
  1344.  
  1345.                         *MsgCode = Node -> Special . Level . Level;
  1346.  
  1347.                         break;
  1348. #endif    /* DO_LEVEL_KIND */
  1349.                     case STRING_KIND:
  1350.                     case INTEGER_KIND:
  1351.                     case FRACTION_KIND:
  1352.                     case PASSWORD_KIND:
  1353.  
  1354.                         Handle -> Previous = *MsgGadget;
  1355.                         break;
  1356. #ifdef DO_TAPEDECK_KIND
  1357.                     case TAPEDECK_KIND:
  1358.  
  1359.                         if(Node -> Special . TapeDeck . Tick)
  1360.                         {
  1361.                             Handle -> ActiveIncrementer    = Node;
  1362.                             Handle -> IncrementerCountdown    = 2;
  1363.                             Handle -> IncrementerAccelerate    = 10;
  1364.                             Handle -> IncrementerIncrement    = 1;
  1365.  
  1366.                             *MsgClass    = IDCMP_GADGETUP;
  1367.                             *MsgCode    = 0;
  1368.                         }
  1369.                         else
  1370.                         {
  1371.                             if(Node -> Special . TapeDeck . Toggle)
  1372.                             {
  1373.                                 if((*MsgGadget) -> Flags & GFLG_SELECTED)
  1374.                                     *MsgCode = TRUE;
  1375.                                 else
  1376.                                     *MsgCode = FALSE;
  1377.  
  1378.                                 Node -> Current = *MsgCode;
  1379.  
  1380.                                 LTP_PutStorage(Node);
  1381.  
  1382.                                 if(Handle -> Previous && !Node -> PageSelector)
  1383.                                     Activate = TRUE;
  1384.  
  1385.                                 *MsgClass = IDCMP_GADGETUP;
  1386.                             }
  1387.                         }
  1388.  
  1389.                         break;
  1390. #endif    /* DO_TAPEDECK_KIND */
  1391.                     case MX_KIND:
  1392.  
  1393.                         if(!V39 && Node -> Disabled)
  1394.                         {
  1395.                             GT_SetGadgetAttrs(*MsgGadget,Handle -> Window,NULL,
  1396.                                 GTMX_Active,Node -> Current,
  1397.                             TAG_DONE);
  1398.  
  1399.                             *MsgClass = NULL;
  1400.                         }
  1401.                         else
  1402.                         {
  1403.                             Node -> Current = *MsgCode;
  1404.  
  1405.                             LTP_PutStorage(Node);
  1406.  
  1407.                             if(Node -> Special . Radio . AutoPageID != -1)
  1408.                             {
  1409.                                 LT_SetAttributes(Handle,Node -> Special . Radio . AutoPageID,
  1410.                                     LAGR_ActivePage,Node -> Current,
  1411.                                 TAG_DONE);
  1412.  
  1413.                                 if(Handle -> Failed)
  1414.                                     *MsgClass = IDCMP_CLOSEWINDOW;
  1415.                                 else
  1416.                                     *MsgClass = NULL;
  1417.                             }
  1418.  
  1419.                             if(Handle -> Previous && !Node -> PageSelector)
  1420.                                 Activate = TRUE;
  1421.                         }
  1422.  
  1423.                         break;
  1424.  
  1425.                     case SLIDER_KIND:
  1426.  
  1427.                         if(Node -> Min < 0)
  1428.                             Node -> Current = (WORD)*MsgCode;
  1429.                         else
  1430.                             Node -> Current = *MsgCode;
  1431.  
  1432.                         LTP_PutStorage(Node);
  1433.  
  1434.                         if(Handle -> Previous && !Node -> PageSelector)
  1435.                             Activate = TRUE;
  1436.  
  1437.                         break;
  1438.  
  1439.                     case SCROLLER_KIND:
  1440.  
  1441.                         Node -> Current = *MsgCode;
  1442.  
  1443.                         LTP_PutStorage(Node);
  1444.  
  1445.                         if(Handle -> Previous && !Node -> PageSelector)
  1446.                             Activate = TRUE;
  1447.  
  1448.                         break;
  1449.  
  1450.                     case INCREMENTER_KIND:
  1451.  
  1452.                         Handle -> ActiveIncrementer    = Node;
  1453.                         Handle -> IncrementerCountdown    = 6;
  1454.                         Handle -> IncrementerAccelerate    = 10;
  1455.                         Handle -> IncrementerIncrement    = 1;
  1456.  
  1457.                         *MsgClass    = IDCMP_GADGETUP;
  1458.                         *MsgCode    = 0;
  1459.                         *MsgGadget    = Node -> Special . Incrementer . Parent;
  1460.  
  1461.                         /* ALWAYS */
  1462.                         {
  1463.                             struct ObjectNode    *Parent = (ObjectNode *)(*MsgGadget) -> UserData;
  1464.                             LONG             Number;
  1465.  
  1466.                             if(Parent -> Special . Integer . IncrementerHook)
  1467.                                 Number = CallHookPkt(Parent -> Special . Integer . IncrementerHook,(APTR)LT_GetAttributes(Handle,Parent -> ID,LAPR_Object,Parent,TAG_DONE),Node -> Special . Incrementer . Amount < 0 ? (APTR)INCREMENTERMSG_DECREMENT : (APTR)INCREMENTERMSG_INCREMENT);
  1468.                             else
  1469.                                 Number = LT_GetAttributes(Handle,Parent -> ID,LAPR_Object,Parent,TAG_DONE) + Node -> Special . Incrementer . Amount;
  1470.  
  1471.                             if(Number >= Parent -> Min && Number <= Parent -> Max)
  1472.                                 LT_SetAttributes(Handle,Parent -> ID,LAPR_Object,Parent,GTIN_Number,Number,TAG_DONE);
  1473.                             else
  1474.                                 *MsgClass = NULL;
  1475.                         }
  1476.  
  1477.                         break;
  1478.                 }
  1479.             }
  1480.  
  1481.             break;
  1482.  
  1483.         case IDCMP_MOUSEBUTTONS:
  1484.  
  1485.             if(((*MsgCode) & IECODE_UP_PREFIX) && Handle -> Previous)
  1486.                 Activate = TRUE;
  1487.  
  1488.             if(*MsgCode == SELECTDOWN)
  1489.             {
  1490.                 ObjectNode    *Node;
  1491.                 WORD         x,y;
  1492.  
  1493.                 x = Handle -> Window -> MouseX;
  1494.                 y = Handle -> Window -> MouseY;
  1495.  
  1496.                 Node = LTP_FindNode_Position(Handle -> TopGroup,x,y);
  1497.  
  1498.                 if(Node && !Node -> Disabled)
  1499.                 {
  1500.                     WORD Index;
  1501.  
  1502.                     switch(Node -> Type)
  1503.                     {
  1504.                         case CHECKBOX_KIND:
  1505.  
  1506.                             Node -> Current = !Node -> Current;
  1507.  
  1508.                             LTP_PutStorage(Node);
  1509.  
  1510.                             GT_SetGadgetAttrs(Node -> Host,Handle -> Window,NULL,
  1511.                                 GTCB_Checked,Node -> Current,
  1512.                             TAG_DONE);
  1513.  
  1514.                             *MsgClass    = IDCMP_GADGETUP;
  1515.                             *MsgCode    = Node -> Current;
  1516.                             *MsgGadget    = Node -> Host;
  1517.  
  1518.                             break;
  1519.  
  1520.                         case MX_KIND:
  1521.  
  1522.                             Index = LTP_Find_Clicked_Item(Handle,Node,x,y);
  1523.  
  1524.                             if(Index != -1)
  1525.                             {
  1526.                                 Node -> Current = Index;
  1527.  
  1528.                                 GT_SetGadgetAttrs(Node -> Host,Handle -> Window,NULL,
  1529.                                     GTMX_Active,Index,
  1530.                                 TAG_DONE);
  1531.  
  1532.                                 LTP_PutStorage(Node);
  1533.  
  1534.                                 *MsgClass    = IDCMP_GADGETDOWN;
  1535.                                 *MsgCode    = Index;
  1536.                                 *MsgGadget    = Node -> Host;
  1537.  
  1538.                                 if(Node -> Special . Cycle . AutoPageID != -1)
  1539.                                 {
  1540.                                     LT_SetAttributes(Handle,Node -> Special . Cycle . AutoPageID,
  1541.                                         LAGR_ActivePage,Index,
  1542.                                     TAG_DONE);
  1543.                                 }
  1544.                             }
  1545.  
  1546.                             break;
  1547.                     }
  1548.                 }
  1549.             }
  1550.             else
  1551.             {
  1552.                     // Now this is a real kludge; as of v37 the
  1553.                     // MX_KIND labels are not part of the gadget
  1554.                     // itself and a plain SELECTDOWN mouse event
  1555.                     // is sent as soon as the user clicks on it.
  1556.                     // This changed with v39 which presumably had
  1557.                     // some code in there to map mouse clicks on
  1558.                     // the gadget labels to proper buttonpress
  1559.                     // events. Now, try as you might the click is
  1560.                     // swallowed and we have to do with the
  1561.                     // SELECTUP, sigh...
  1562.  
  1563.                 if(V39 && *MsgCode == SELECTUP)
  1564.                 {
  1565.                     ObjectNode    *Node;
  1566.                     WORD         x,y;
  1567.  
  1568.                     x = Handle -> Window -> MouseX;
  1569.                     y = Handle -> Window -> MouseY;
  1570.  
  1571.                     Node = LTP_FindNode_Position(Handle -> TopGroup,x,y);
  1572.  
  1573.                     if(Node && Node -> Type == MX_KIND && !Node -> Disabled)
  1574.                     {
  1575.                         WORD Index;
  1576.  
  1577.                         Index = LTP_Find_Clicked_Item(Handle,Node,x,y);
  1578.  
  1579.                         if(Index != -1)
  1580.                         {
  1581.                             GT_SetGadgetAttrs(Node -> Host,Handle -> Window,NULL,
  1582.                                 GTMX_Active,Index,
  1583.                             TAG_DONE);
  1584.  
  1585.                             Node -> Current = Index;
  1586.  
  1587.                             LTP_PutStorage(Node);
  1588.  
  1589.                             *MsgClass    = IDCMP_GADGETDOWN;
  1590.                             *MsgCode    = Index;
  1591.                             *MsgGadget    = Node -> Host;
  1592.  
  1593.                             if(Node -> Special . Cycle . AutoPageID != -1)
  1594.                             {
  1595.                                 LT_SetAttributes(Handle,Node -> Special . Cycle . AutoPageID,
  1596.                                     LAGR_ActivePage,Index,
  1597.                                 TAG_DONE);
  1598.                             }
  1599.                         }
  1600.                     }
  1601.                 }
  1602.             }
  1603.  
  1604.             if((*MsgCode == SELECTUP) && (Handle -> ActiveIncrementer))
  1605.             {
  1606.                 if(Handle -> ActiveIncrementer -> Type == TAPEDECK_KIND && Handle -> ActiveIncrementer  -> Special . TapeDeck . Tick)
  1607.                 {
  1608.                     Handle -> ActiveIncrementer = NULL;
  1609.  
  1610.                     *MsgClass    = IDCMP_GADGETUP;
  1611.                     *MsgCode    = 1;
  1612.                 }
  1613.                 else
  1614.                 {
  1615.                     if(((ObjectNode *)Handle -> ActiveIncrementer -> Special . Incrementer . Parent -> UserData) -> Type == INTEGER_KIND)
  1616.                     {
  1617.                         *MsgGadget    = Handle -> ActiveIncrementer -> Special . Incrementer . Parent;
  1618.                         *MsgClass    = IDCMP_GADGETUP;
  1619.                         *MsgCode    = 1;
  1620.                     }
  1621.  
  1622.                     Handle -> ActiveIncrementer = NULL;
  1623.                 }
  1624.             }
  1625.  
  1626.             break;
  1627.  
  1628.         case IDCMP_GADGETUP:
  1629.  
  1630. #ifdef DO_LEVEL_KIND
  1631.             Handle -> CurrentLevel = NULL;
  1632. #endif    /* DO_LEVEL_KIND */
  1633.  
  1634.             if(GETOBJECT((*MsgGadget),Node))
  1635.             {
  1636.                 if(Node -> Type != LISTVIEW_KIND)
  1637.                     Handle -> ClickSeconds = Handle -> ClickMicros = 0;
  1638.  
  1639.                 switch(Node -> Type)
  1640.                 {
  1641.                     case FRACTION_KIND:
  1642.  
  1643.                         LT_SetAttributes(Handle,(*MsgGadget) -> GadgetID,LAFC_Number,LT_GetAttributes(Handle,(*MsgGadget) -> GadgetID,TAG_DONE),TAG_DONE);
  1644.  
  1645.                     /* FALLS THROUGH */
  1646.  
  1647.                     case PASSWORD_KIND:
  1648.                     case STRING_KIND:
  1649.  
  1650.                         LTP_PutStorage(Node);
  1651.  
  1652.                         if(*MsgCode == 0x5F && Handle -> HelpHook)
  1653.                         {
  1654.                             struct HelpMsg     Message;
  1655.                             struct IBox     Box;
  1656.  
  1657.                             Message . ObjectID = Node -> ID;
  1658.  
  1659.                             Box . Left    = Node -> Left;
  1660.                             Box . Top    = Node -> Top;
  1661.                             Box . Width    = Node -> Width;
  1662.                             Box . Height    = Node -> Height;
  1663.  
  1664.                             Message . Handle = Handle;
  1665.  
  1666.                             CallHookPkt(Handle -> HelpHook,&Message,&Box);
  1667.  
  1668.                             *MsgClass = NULL;
  1669.                         }
  1670.                         else
  1671.                             Handle -> Previous = NULL;
  1672.  
  1673.                         break;
  1674.  
  1675.                     case INTEGER_KIND:
  1676.                     {
  1677.                         struct StringInfo *StringInfo = (struct StringInfo *)(*MsgGadget) -> SpecialInfo;
  1678.                         LONG Contents = StringInfo -> LongInt;
  1679.  
  1680.                         if(Contents < Node -> Min)
  1681.                             Contents = Node -> Min;
  1682.                         else
  1683.                         {
  1684.                             if(Contents > Node -> Max)
  1685.                                 Contents = Node -> Max;
  1686.                         }
  1687.  
  1688.                         LT_SetAttributes(Handle,(*MsgGadget) -> GadgetID,GTIN_Number,Contents,TAG_DONE);
  1689.  
  1690.                         LTP_PutStorage(Node);
  1691.  
  1692.                         if(*MsgCode == 0x5F && Handle -> HelpHook)
  1693.                         {
  1694.                             struct HelpMsg     Message;
  1695.                             struct IBox     Box;
  1696.  
  1697.                             Message . ObjectID = Node -> ID;
  1698.  
  1699.                             Box . Left    = Node -> Left;
  1700.                             Box . Top    = Node -> Top;
  1701.                             Box . Width    = Node -> Width;
  1702.                             Box . Height    = Node -> Height;
  1703.  
  1704.                             Message . Handle = Handle;
  1705.  
  1706.                             CallHookPkt(Handle -> HelpHook,&Message,&Box);
  1707.  
  1708.                             *MsgClass = NULL;
  1709.                         }
  1710.                         else
  1711.                             Handle -> Previous = NULL;
  1712.  
  1713.                         break;
  1714.                     }
  1715.  
  1716.                     case CHECKBOX_KIND:
  1717.  
  1718.                         if(!V39)
  1719.                         {
  1720.                             if((*MsgGadget) -> Flags & GFLG_SELECTED)
  1721.                                 *MsgCode = TRUE;
  1722.                             else
  1723.                                 *MsgCode = FALSE;
  1724.                         }
  1725.  
  1726.                         Node -> Current = *MsgCode;
  1727.  
  1728.                         LTP_PutStorage(Node);
  1729.  
  1730.                         if(Handle -> Previous && !Node -> PageSelector)
  1731.                             Activate = TRUE;
  1732.  
  1733.                         break;
  1734. #ifdef DO_TAPEDECK_KIND
  1735.                     case TAPEDECK_KIND:
  1736.  
  1737.                         if(Node -> Special . TapeDeck . Tick)
  1738.                         {
  1739.                             Handle -> ActiveIncrementer = NULL;
  1740.  
  1741.                             *MsgClass    = IDCMP_GADGETUP;
  1742.                             *MsgCode    = 1;
  1743.                         }
  1744.                         else
  1745.                         {
  1746.                             if(Node -> Special . TapeDeck . Toggle)
  1747.                             {
  1748.                                 if((*MsgGadget) -> Flags & GFLG_SELECTED)
  1749.                                     *MsgCode = TRUE;
  1750.                                 else
  1751.                                     *MsgCode = FALSE;
  1752.  
  1753.                                 Node -> Current = *MsgCode;
  1754.  
  1755.                                 LTP_PutStorage(Node);
  1756.                             }
  1757.                         }
  1758.  
  1759.                         if(Handle -> Previous && !Node -> PageSelector)
  1760.                             Activate = TRUE;
  1761.  
  1762.                         break;
  1763. #endif    /* DO_TAPEDECK_KIND */
  1764. #if defined(DO_POPUP_KIND) && defined(DO_BOOPSI_KIND)
  1765.                     case POPUP_KIND:
  1766.  
  1767.                         Node -> Current = *MsgCode;
  1768.  
  1769.                         LTP_PutStorage(Node);
  1770.  
  1771.                         if(Handle -> Previous && !Node -> PageSelector)
  1772.                             Activate = TRUE;
  1773.  
  1774.                         if(Node -> Special . Popup . AutoPageID != -1)
  1775.                         {
  1776.                             LT_SetAttributes(Handle,Node -> Special . Popup . AutoPageID,
  1777.                                 LAGR_ActivePage,Node -> Current,
  1778.                             TAG_DONE);
  1779.  
  1780.                             if(Handle -> Failed)
  1781.                                 *MsgClass = IDCMP_CLOSEWINDOW;
  1782.                             else
  1783.                                 *MsgClass = NULL;
  1784.                         }
  1785.  
  1786.                         break;
  1787. #endif
  1788.  
  1789. #if defined(DO_TAB_KIND) && defined(DO_BOOPSI_KIND)
  1790.                     case TAB_KIND:
  1791.  
  1792.                         Node -> Current = *MsgCode;
  1793.  
  1794.                         LTP_PutStorage(Node);
  1795.  
  1796.                         if(Handle -> Previous && !Node -> PageSelector)
  1797.                             Activate = TRUE;
  1798.  
  1799.                         if(Node -> Special . Tab . AutoPageID != -1)
  1800.                         {
  1801.                             LT_SetAttributes(Handle,Node -> Special . Tab . AutoPageID,
  1802.                                 LAGR_ActivePage,Node -> Current,
  1803.                             TAG_DONE);
  1804.  
  1805.                             if(Handle -> Failed)
  1806.                                 *MsgClass = IDCMP_CLOSEWINDOW;
  1807.                             else
  1808.                                 *MsgClass = NULL;
  1809.                         }
  1810.  
  1811.                         break;
  1812. #endif
  1813.                     case CYCLE_KIND:
  1814.  
  1815.                         Node -> Current = *MsgCode;
  1816.  
  1817.                         LTP_PutStorage(Node);
  1818.  
  1819.                         if(Handle -> Previous && !Node -> PageSelector)
  1820.                             Activate = TRUE;
  1821.  
  1822.                         if(Node -> Special . Cycle . AutoPageID != -1)
  1823.                         {
  1824.                             LT_SetAttributes(Handle,Node -> Special . Cycle . AutoPageID,
  1825.                                 LAGR_ActivePage,Node -> Current,
  1826.                             TAG_DONE);
  1827.  
  1828.                             if(Handle -> Failed)
  1829.                                 *MsgClass = IDCMP_CLOSEWINDOW;
  1830.                             else
  1831.                                 *MsgClass = NULL;
  1832.                         }
  1833.  
  1834.                         break;
  1835.  
  1836.                     case PALETTE_KIND:
  1837.  
  1838.                         Node -> Current = *MsgCode;
  1839.  
  1840.                         LTP_PutStorage(Node);
  1841.  
  1842.                         if(Handle -> Previous && !Node -> PageSelector)
  1843.                             Activate = TRUE;
  1844.  
  1845.                         break;
  1846.  
  1847.                     case MX_KIND:
  1848.  
  1849.                         if(!V39 && Node -> Disabled)
  1850.                         {
  1851.                             GT_SetGadgetAttrs(*MsgGadget,Handle -> Window,NULL,
  1852.                                 GTMX_Active,Node -> Current,
  1853.                             TAG_DONE);
  1854.  
  1855.                             *MsgClass = NULL;
  1856.                         }
  1857.                         else
  1858.                         {
  1859.                             Node -> Current = *MsgCode;
  1860.  
  1861.                             LTP_PutStorage(Node);
  1862.  
  1863.                             if(Node -> Special . Radio . AutoPageID != -1)
  1864.                             {
  1865.                                 LT_SetAttributes(Handle,Node -> Special . Radio . AutoPageID,
  1866.                                     LAGR_ActivePage,Node -> Current,
  1867.                                 TAG_DONE);
  1868.  
  1869.                                 if(Handle -> Failed)
  1870.                                     *MsgClass = IDCMP_CLOSEWINDOW;
  1871.                                 else
  1872.                                     *MsgClass = NULL;
  1873.                             }
  1874.  
  1875.                             if(Handle -> Previous && !Node -> PageSelector)
  1876.                                 Activate = TRUE;
  1877.                         }
  1878.  
  1879.                         break;
  1880.  
  1881.                     case SLIDER_KIND:
  1882.  
  1883.                         if(Node -> Min < 0)
  1884.                             Node -> Current = (WORD)*MsgCode;
  1885.                         else
  1886.                             Node -> Current = *MsgCode;
  1887.  
  1888.                         LTP_PutStorage(Node);
  1889.  
  1890.                         if(Handle -> Previous && !Node -> PageSelector)
  1891.                             Activate = TRUE;
  1892.  
  1893.                         break;
  1894. #ifdef DO_LEVEL_KIND
  1895.                     case LEVEL_KIND:
  1896.  
  1897. //                        *MsgClass    = IDCMP_MOUSEMOVE;    // Careful, may cause trouble with existing applications!
  1898.                         *MsgCode    = Node -> Special . Level . Level;
  1899.                         *MsgGadget    = Node -> Host;
  1900.  
  1901.                         LTP_PutStorage(Node);
  1902.  
  1903.                         break;
  1904. #endif    /* DO_LEVEL_KIND */
  1905.                     case SCROLLER_KIND:
  1906.  
  1907.                         Node -> Current = *MsgCode;
  1908.  
  1909.                         LTP_PutStorage(Node);
  1910.  
  1911.                         if(Handle -> Previous && !Node -> PageSelector)
  1912.                             Activate = TRUE;
  1913.  
  1914.                         break;
  1915.  
  1916.                     case PICKER_KIND:
  1917.  
  1918.                         *MsgClass    = IDCMP_IDCMPUPDATE;
  1919.                         *MsgCode    = 0;
  1920.                         *MsgGadget    = Node -> Special . Picker . Parent;
  1921.  
  1922.                         if(Handle -> Previous && !Node -> PageSelector)
  1923.                             Activate = TRUE;
  1924.  
  1925.                         break;
  1926.  
  1927.                     case INCREMENTER_KIND:
  1928.  
  1929.                         if(((ObjectNode *)Handle -> ActiveIncrementer -> Special . Incrementer . Parent -> UserData) -> Type == INTEGER_KIND)
  1930.                         {
  1931.                             *MsgGadget    = Handle -> ActiveIncrementer -> Special . Incrementer . Parent;
  1932.                             *MsgClass    = IDCMP_GADGETUP;
  1933.                             *MsgCode    = 1;
  1934.                         }
  1935.  
  1936.                         Handle -> ActiveIncrementer = NULL;
  1937.                         break;
  1938.  
  1939.                     case LISTVIEW_KIND:
  1940.  
  1941.                         if(Node -> Current != *MsgCode || Node != Handle -> ClickObject)
  1942.                         {
  1943.                             CurrentTime(&Handle -> ClickSeconds,&Handle -> ClickMicros);
  1944.  
  1945.                             Handle -> ClickObject = Node;
  1946.                         }
  1947.                         else
  1948.                         {
  1949.                             ULONG Seconds,Micros;
  1950.  
  1951.                             CurrentTime(&Seconds,&Micros);
  1952.  
  1953.                             if(DoubleClick(Handle -> ClickSeconds,Handle -> ClickMicros,Seconds,Micros))
  1954.                                 *MsgClass = IDCMP_IDCMPUPDATE;
  1955.  
  1956.                             Handle -> ClickSeconds    = Seconds;
  1957.                             Handle -> ClickMicros    = Micros;
  1958.                         }
  1959.  
  1960.                         Node -> Current = *MsgCode;
  1961.  
  1962.                         LTP_PutStorage(Node);
  1963.  
  1964.                         if(Node -> Special . List . AutoPageID != -1)
  1965.                         {
  1966.                             LT_SetAttributes(Handle,Node -> Special . List . AutoPageID,
  1967.                                 LAGR_ActivePage,Node -> Current,
  1968.                             TAG_DONE);
  1969.                         }
  1970.  
  1971.                         if(Node -> Special . List . Link)
  1972.                         {
  1973.                             Handle -> Previous = Node -> Special . List . Link;
  1974.  
  1975.                             if(!Node -> PageSelector)
  1976.                                 Activate = TRUE;
  1977.                         }
  1978.                         else
  1979.                         {
  1980.                             if(Handle -> Previous && !Node -> PageSelector)
  1981.                                 Activate = TRUE;
  1982.                         }
  1983.  
  1984.                         break;
  1985.  
  1986.                     default:
  1987.  
  1988.                         if(Handle -> Previous && !Node -> PageSelector)
  1989.                             Activate = TRUE;
  1990.  
  1991.                         break;
  1992.                 }
  1993.             }
  1994.  
  1995.             break;
  1996.  
  1997.         case IDCMP_MOUSEMOVE:
  1998.  
  1999. #ifdef DO_LEVEL_KIND
  2000.             if(Handle -> CurrentLevel)
  2001.                 Node = Handle -> CurrentLevel;
  2002.             else
  2003. #endif
  2004.                 GETOBJECT((*MsgGadget),Node);
  2005.  
  2006.             if(Node)
  2007.             {
  2008.                 if(Node -> Type != LISTVIEW_KIND)
  2009.                     Handle -> ClickSeconds = Handle -> ClickMicros = 0;
  2010.  
  2011.                 switch(Node -> Type)
  2012.                 {
  2013.                     case SLIDER_KIND:
  2014.  
  2015.                         if(Node -> Min < 0)
  2016.                             Node -> Current = (WORD)*MsgCode;
  2017.                         else
  2018.                             Node -> Current = *MsgCode;
  2019.  
  2020.                         LTP_PutStorage(Node);
  2021.  
  2022.                         break;
  2023.  
  2024.                     case SCROLLER_KIND:
  2025.  
  2026.                         Node -> Current = *MsgCode;
  2027.  
  2028.                         LTP_PutStorage(Node);
  2029.  
  2030.                         break;
  2031.  
  2032. #ifdef DO_LEVEL_KIND
  2033.                     case LEVEL_KIND:
  2034.  
  2035.                         *MsgCode    = Node -> Special . Level . Level;
  2036.                         *MsgGadget      = Node -> Host;
  2037.  
  2038.                         LTP_PutStorage(Node);
  2039.  
  2040.                         break;
  2041. #endif    /* DO_LEVEL_KIND */
  2042.                 }
  2043.             }
  2044.  
  2045.             break;
  2046.  
  2047.         case IDCMP_ACTIVEWINDOW:
  2048.  
  2049.             if(Handle -> Previous)
  2050.             {
  2051.                 Activate = TRUE;
  2052.  
  2053.                 *MsgClass    = IDCMP_GADGETDOWN;
  2054.                 *MsgCode    = 0;
  2055.                 *MsgGadget    = Handle -> Previous;
  2056.             }
  2057.  
  2058.             break;
  2059.  
  2060.         case IDCMP_INACTIVEWINDOW:
  2061.  
  2062.             Handle -> ActiveIncrementer = NULL;
  2063.             break;
  2064.     }
  2065.  
  2066.     if(Handle -> AutoActivate && Activate && Handle -> Previous)
  2067.     {
  2068.         if(GETOBJECT(Handle -> Previous,Node))
  2069.         {
  2070.             if(!Node -> Disabled)
  2071.             {
  2072.                 if(Node -> Type == BOOPSI_KIND)
  2073.                 {
  2074.                     if(Node -> Special . BOOPSI . ActivateHook)
  2075.                         CallHookPkt(Node -> Special . BOOPSI . ActivateHook,(APTR)Handle,(APTR)Node -> Host);
  2076.                 }
  2077.                 else
  2078.                     ActivateGadget(Handle -> Previous,Handle -> Window,NULL);
  2079.             }
  2080.         }
  2081.     }
  2082. }
  2083.